home *** CD-ROM | disk | FTP | other *** search
/ Giga Games 1 / Giga Games.iso / net / usenet / volume2 / nethack / part03 < prev    next >
Encoding:
Internet Message Format  |  1987-07-29  |  54.6 KB
  1. Path: uunet!seismo!rutgers!ucla-cs!zen!ucbvax!decvax!tektronix!tekgen!tekred!games-request
  2. From: games-request@tekred.TEK.COM
  3. Newsgroups: comp.sources.games
  4. Subject: v02i003:  nethack - display oriented dungeons & dragons, Part03/16
  5. Message-ID: <1445@tekred.TEK.COM>
  6. Date: 28 Jul 87 17:21:42 GMT
  7. Sender: billr@tekred.TEK.COM
  8. Lines: 2298
  9. Approved: billr@tekred.TEK.COM
  10.  
  11. Submitted by: mike@genat.UUCP (Mike Stephenson)
  12. Comp.sources.games: Volume 2, Issue 3
  13. Archive-name: nethack/Part03
  14.  
  15.  
  16. #! /bin/sh
  17. # This is a shell archive.  Remove anything before this line, then unpack
  18. # it by saving it into a file and typing "sh file".  To overwrite existing
  19. # files, type "sh file -c".  You can also feed this as standard input via
  20. # unshar, or by typing "sh <file", e.g..  If this archive is complete, you
  21. # will see the following message at the end:
  22. #        "End of archive 3 (of 16)."
  23. # Contents:  hack.c wield.c zap.c
  24. # Wrapped by billr@tekred on Tue Jul 28 09:49:22 1987
  25. PATH=/bin:/usr/bin:/usr/ucb ; export PATH
  26. if test -f hack.c -a "${1}" != "-c" ; then 
  27.   echo shar: Will not over-write existing file \"hack.c\"
  28. else
  29. echo shar: Extracting \"hack.c\" \(24139 characters\)
  30. sed "s/^X//" >hack.c <<'END_OF_hack.c'
  31. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  32. X/* hack.c - version 1.0.3 */
  33. X
  34. X#include <stdio.h>
  35. X#include "hack.h"
  36. X#ifdef UNIX
  37. Xstatic    char    SCCS_Id[] = "@(#)hack.c    1.3\t87/07/14";
  38. X#endif
  39. Xextern char news0();
  40. Xextern char *nomovemsg;
  41. Xextern char *exclam();
  42. Xextern struct obj *addinv();
  43. Xextern boolean hmon();
  44. X
  45. X/* called on movement:
  46. X    1. when throwing ball+chain far away
  47. X    2. when teleporting
  48. X    3. when walking out of a lit room
  49. X */
  50. Xunsee() {
  51. X    register x,y;
  52. X    register struct rm *lev;
  53. X
  54. X/*
  55. X    if(u.udispl){
  56. X        u.udispl = 0;
  57. X        newsym(u.udisx, u.udisy);
  58. X    }
  59. X*/
  60. X#ifndef QUEST
  61. X    if(seehx){
  62. X        seehx = 0;
  63. X    } else
  64. X#endif
  65. X    for(x = u.ux-1; x < u.ux+2; x++)
  66. X      for(y = u.uy-1; y < u.uy+2; y++) {
  67. X        if(!isok(x, y)) continue;
  68. X        lev = &levl[x][y];
  69. X#ifdef DGK
  70. X        if(!lev->lit && lev->scrsym == symbol.room) {
  71. X#else
  72. X        if(!lev->lit && lev->scrsym == '.') {
  73. X#endif
  74. X            lev->scrsym =' ';
  75. X            lev->new = 1;
  76. X            on_scr(x,y);
  77. X        }
  78. X    }
  79. X}
  80. X
  81. X/* called:
  82. X    in apply.c:  seeoff(0) - when taking a picture of yourself
  83. X    in do.c:     seeoff(0) - blind after drinking potion
  84. X    in do.c:     seeoff(1) - go up or down the stairs
  85. X    in eat.c:    seeoff(0) - blind after eating rotten food
  86. X    in mhitu.c:  seeoff(0) - blinded by a yellow light
  87. X    in mon.c:    seeoff(1) - swallowed
  88. X    in potion.c: seeoff(0) - quaffing or sniffing a potion of blindness
  89. X    in spell.c:  seeoff(0) - due to a cursed spellbook
  90. X    in trap.c:   seeoff(1) - fall through trapdoor
  91. X    in wizard.c: seeoff(0) - hit by a cream pie.
  92. X */
  93. Xseeoff(mode)    /* 1 to redo @, 0 to leave them */
  94. X{    /* 1 means misc movement, 0 means blindness */
  95. X    register x,y;
  96. X    register struct rm *lev;
  97. X
  98. X    if(u.udispl && mode){
  99. X        u.udispl = 0;
  100. X        levl[u.udisx][u.udisy].scrsym = news0(u.udisx,u.udisy);
  101. X    }
  102. X#ifndef QUEST
  103. X    if(seehx) {
  104. X        seehx = 0;
  105. X    } else
  106. X#endif
  107. X    if(!mode) {
  108. X        for(x = u.ux-1; x < u.ux+2; x++)
  109. X            for(y = u.uy-1; y < u.uy+2; y++) {
  110. X                if(!isok(x, y)) continue;
  111. X                lev = &levl[x][y];
  112. X#ifdef DGK
  113. X                if(!lev->lit && lev->scrsym == symbol.room)
  114. X#else
  115. X                if(!lev->lit && lev->scrsym == '.')
  116. X#endif
  117. X                    lev->seen = 0;
  118. X            }
  119. X    }
  120. X}
  121. X
  122. Xstatic
  123. Xmoverock() {
  124. X    register xchar rx, ry;
  125. X    register struct obj *otmp;
  126. X    register struct trap *ttmp;
  127. X
  128. X    while(otmp = sobj_at(ENORMOUS_ROCK, u.ux+u.dx, u.uy+u.dy)) {
  129. X        rx = u.ux+2*u.dx;
  130. X        ry = u.uy+2*u.dy;
  131. X        nomul(0);
  132. X        if(isok(rx,ry) && !IS_ROCK(levl[rx][ry].typ) &&
  133. X            (levl[rx][ry].typ != DOOR || !(u.dx && u.dy)) &&
  134. X            !sobj_at(ENORMOUS_ROCK, rx, ry)) {
  135. X            if(m_at(rx,ry)) {
  136. X                pline("You hear a monster behind the rock.");
  137. X                pline("Perhaps that's why you cannot move it.");
  138. X                goto cannot_push;
  139. X            }
  140. X            if(ttmp = t_at(rx,ry))
  141. X                switch(ttmp->ttyp) {
  142. X                case PIT:
  143. X                pline("You push the rock into a pit!");
  144. X                deltrap(ttmp);
  145. X                delobj(otmp);
  146. X                pline("It completely fills the pit!");
  147. X                continue;
  148. X                case TELEP_TRAP:
  149. X                pline("You push the rock and suddenly it disappears!");
  150. X                delobj(otmp);
  151. X                continue;
  152. X                }
  153. X            if(levl[rx][ry].typ == POOL) {
  154. X                levl[rx][ry].typ = ROOM;
  155. X                mnewsym(rx,ry);
  156. X                prl(rx,ry);
  157. X                pline("You push the rock into the water.");
  158. X                pline("Now you can cross the water!");
  159. X                delobj(otmp);
  160. X                continue;
  161. X            }
  162. X            otmp->ox = rx;
  163. X            otmp->oy = ry;
  164. X            /* pobj(otmp); */
  165. X            if(cansee(rx,ry)) atl(rx,ry,otmp->olet);
  166. X            if(Invisible) newsym(u.ux+u.dx, u.uy+u.dy);
  167. X
  168. X            { static long lastmovetime;
  169. X            /* note: this var contains garbage initially and
  170. X               after a restore */
  171. X            if(moves > lastmovetime+2 || moves < lastmovetime)
  172. X            pline("With great effort you move the enormous rock.");
  173. X            lastmovetime = moves;
  174. X            }
  175. X        } else {
  176. X            pline("You try to move the enormous rock, but in vain.");
  177. X        cannot_push:
  178. X#ifdef KAA
  179. X            if (u.usym=='9') {
  180. X# ifdef DGKMOD
  181. X            if(!flags.pickup)
  182. X                pline("You easily can push it aside.");
  183. X            else
  184. X# endif
  185. X                pline("However, you easily can pick it up.");
  186. X            break;
  187. X            }
  188. X#endif
  189. X            if((!invent || inv_weight()+90 <= 0) &&
  190. X            (!u.dx || !u.dy || (IS_ROCK(levl[u.ux][u.uy+u.dy].typ)
  191. X                    && IS_ROCK(levl[u.ux+u.dx][u.uy].typ)))){
  192. X            pline("However, you can squeeze yourself into a small opening.");
  193. X            break;
  194. X            } else
  195. X            return (-1);
  196. X        }
  197. X    }
  198. X    return (0);
  199. X}
  200. X
  201. Xdomove()
  202. X{
  203. X    register struct monst *mtmp;
  204. X    register struct rm *tmpr,*ust;
  205. X    struct trap *trap;
  206. X    register struct obj *otmp;
  207. X
  208. X    u_wipe_engr(rnd(5));
  209. X
  210. X    if(inv_weight() > 0){
  211. X        pline("You collapse under your load.");
  212. X        nomul(0);
  213. X        return;
  214. X    }
  215. X    if(u.uswallow) {
  216. X        u.dx = u.dy = 0;
  217. X        u.ux = u.ustuck->mx;
  218. X        u.uy = u.ustuck->my;
  219. X    } else {
  220. X        if(Confusion) {
  221. X            do {
  222. X                confdir();
  223. X            } while(!isok(u.ux+u.dx, u.uy+u.dy) ||
  224. X                IS_ROCK(levl[u.ux+u.dx][u.uy+u.dy].typ));
  225. X        }
  226. X        if(!isok(u.ux+u.dx, u.uy+u.dy)){
  227. X            nomul(0);
  228. X            return;
  229. X        }
  230. X    }
  231. X
  232. X    ust = &levl[u.ux][u.uy];
  233. X    u.ux0 = u.ux;
  234. X    u.uy0 = u.uy;
  235. X    if(!u.uswallow && (trap = t_at(u.ux+u.dx, u.uy+u.dy)) && trap->tseen)
  236. X        nomul(0);
  237. X    if(u.ustuck && !u.uswallow && (u.ux+u.dx != u.ustuck->mx ||
  238. X        u.uy+u.dy != u.ustuck->my)) {
  239. X        if(dist(u.ustuck->mx, u.ustuck->my) > 2){
  240. X            /* perhaps it fled (or was teleported or ... ) */
  241. X            u.ustuck = 0;
  242. X        } else {
  243. X            if(Blind) pline("You cannot escape from it!");
  244. X            else pline("You cannot escape from %s!",
  245. X                monnam(u.ustuck));
  246. X            nomul(0);
  247. X            return;
  248. X        }
  249. X    }
  250. X    if(u.uswallow || (mtmp = m_at(u.ux+u.dx,u.uy+u.dy))) {
  251. X    /* attack monster */
  252. X
  253. X#ifdef SAFE_ATTACK
  254. X        /* Don't attack if you're running */
  255. X        if (flags.run && !mtmp->mimic
  256. X        && (Blind ? Telepat : (!mtmp->minvis || See_invisible))) {
  257. X            nomul(0);
  258. X            flags.move = 0;
  259. X            return;
  260. X        }
  261. X#endif
  262. X        nomul(0);
  263. X        gethungry();
  264. X        if(multi < 0) return;    /* we just fainted */
  265. X
  266. X        /* try to attack; note that it might evade */
  267. X        if(attack(u.uswallow ? u.ustuck : mtmp))
  268. X            return;
  269. X    }
  270. X    /* not attacking an animal, so we try to move */
  271. X    if(u.utrap) {
  272. X        if(u.utraptype == TT_PIT) {
  273. X            pline("You are still in a pit.");
  274. X            u.utrap--;
  275. X        } else {
  276. X            pline("You are caught in a beartrap.");
  277. X            if((u.dx && u.dy) || !rn2(5)) u.utrap--;
  278. X        }
  279. X        return;
  280. X    }
  281. X    tmpr = &levl[u.ux+u.dx][u.uy+u.dy];
  282. X    if(IS_ROCK(tmpr->typ) ||
  283. X       (u.dx && u.dy && (tmpr->typ == DOOR || ust->typ == DOOR))){
  284. X        flags.move = 0;
  285. X        nomul(0);
  286. X        return;
  287. X    }
  288. X    if(moverock() < 0) return;
  289. X    if(u.dx && u.dy && IS_ROCK(levl[u.ux][u.uy+u.dy].typ) &&
  290. X        IS_ROCK(levl[u.ux+u.dx][u.uy].typ) &&
  291. X        invent && inv_weight()+40 > 0) {
  292. X        pline("You are carrying too much to get through.");
  293. X        nomul(0);
  294. X        return;
  295. X    }
  296. X    if(Punished &&
  297. X       DIST(u.ux+u.dx, u.uy+u.dy, uchain->ox, uchain->oy) > 2){
  298. X        if(carried(uball)) {
  299. X            movobj(uchain, u.ux, u.uy);
  300. X            goto nodrag;
  301. X        }
  302. X
  303. X        if(DIST(u.ux+u.dx, u.uy+u.dy, uball->ox, uball->oy) < 3){
  304. X            /* leave ball, move chain under/over ball */
  305. X            movobj(uchain, uball->ox, uball->oy);
  306. X            goto nodrag;
  307. X        }
  308. X
  309. X        if(inv_weight() + (int) uball->owt/2 > 0) {
  310. X            pline("You cannot %sdrag the heavy iron ball.",
  311. X            invent ? "carry all that and also " : "");
  312. X            nomul(0);
  313. X            return;
  314. X        }
  315. X
  316. X        movobj(uball, uchain->ox, uchain->oy);
  317. X        unpobj(uball);        /* BAH %% */
  318. X        uchain->ox = u.ux;
  319. X        uchain->oy = u.uy;
  320. X        nomul(-2);
  321. X        nomovemsg = "";
  322. X    nodrag:    ;
  323. X    }
  324. X    u.ux += u.dx;
  325. X    u.uy += u.dy;
  326. X    if(flags.run) {
  327. X        if(tmpr->typ == DOOR ||
  328. X        (xupstair == u.ux && yupstair == u.uy) ||
  329. X        (xdnstair == u.ux && ydnstair == u.uy)
  330. X#ifdef FOUNTAINS
  331. X        || IS_FOUNTAIN(levl[u.ux][u.uy].typ)
  332. X#endif
  333. X#ifdef NEWCLASS
  334. X        || IS_THRONE(levl[u.ux][u.uy].typ)
  335. X#endif
  336. X        )
  337. X            nomul(0);
  338. X    }
  339. X
  340. X    if(tmpr->typ == POOL && !Levitation)
  341. X        drown();    /* not necessarily fatal */
  342. X
  343. X/*
  344. X    if(u.udispl) {
  345. X        u.udispl = 0;
  346. X        newsym(u.ux0,u.uy0);
  347. X    }
  348. X*/
  349. X    if(!Blind) {
  350. X#ifdef QUEST
  351. X        setsee();
  352. X#else
  353. X        if(ust->lit) {
  354. X            if(tmpr->lit) {
  355. X                if(tmpr->typ == DOOR)
  356. X                    prl1(u.ux+u.dx,u.uy+u.dy);
  357. X                else if(ust->typ == DOOR)
  358. X                    nose1(u.ux0-u.dx,u.uy0-u.dy);
  359. X            } else {
  360. X                unsee();
  361. X                prl1(u.ux+u.dx,u.uy+u.dy);
  362. X            }
  363. X        } else {
  364. X            if(tmpr->lit) setsee();
  365. X            else {
  366. X                prl1(u.ux+u.dx,u.uy+u.dy);
  367. X                if(tmpr->typ == DOOR) {
  368. X                    if(u.dy) {
  369. X                        prl(u.ux-1,u.uy);
  370. X                        prl(u.ux+1,u.uy);
  371. X                    } else {
  372. X                        prl(u.ux,u.uy-1);
  373. X                        prl(u.ux,u.uy+1);
  374. X                    }
  375. X                }
  376. X            }
  377. X            nose1(u.ux0-u.dx,u.uy0-u.dy);
  378. X        }
  379. X#endif /* QUEST /**/
  380. X    } else {
  381. X        pru();
  382. X    }
  383. X    if(!flags.nopick) pickup(1);
  384. X    if(trap) dotrap(trap);        /* fall into pit, arrow trap, etc. */
  385. X    (void) inshop();
  386. X    if(!Blind) read_engr_at(u.ux,u.uy);
  387. X}
  388. X
  389. Xmovobj(obj, ox, oy)
  390. Xregister struct obj *obj;
  391. Xregister int ox, oy;
  392. X{
  393. X    /* Some dirty programming to get display right */
  394. X    freeobj(obj);
  395. X    unpobj(obj);
  396. X    obj->nobj = fobj;
  397. X    fobj = obj;
  398. X    obj->ox = ox;
  399. X    obj->oy = oy;
  400. X}
  401. X
  402. Xdopickup(){
  403. X    /* uswallow case added by GAN 01/29/87 */
  404. X    if(u.uswallow)  {
  405. X        pline("You pick up %s's tongue.",monnam(u.ustuck));
  406. X        pline("But it's kind of slimy, so you drop it.");
  407. X        return(1);
  408. X    }
  409. X    if(!g_at(u.ux,u.uy) && !o_at(u.ux,u.uy)) {
  410. X        pline("There is nothing here to pick up.");
  411. X        return(0);
  412. X    }
  413. X    if(Levitation) {
  414. X        pline("You cannot reach the floor.");
  415. X        return(1);
  416. X    }
  417. X    pickup(0);
  418. X    return(1);
  419. X}
  420. X
  421. Xpickup(all)
  422. X{
  423. X    register struct gold *gold;
  424. X    register struct obj *obj, *obj2;
  425. X    register int wt;
  426. X    char buf[BUFSZ];
  427. X    register char *ip;
  428. X    register char sym;
  429. X    register int oletct = 0, iletct = 0;
  430. X    char olets[20], ilets[20];
  431. X
  432. X    if(Levitation) return;
  433. X#ifdef DGKMOD
  434. X    if (all && !flags.pickup) {
  435. X        int ct = 0;
  436. X
  437. X        for (obj = fobj; obj; obj = obj->nobj)
  438. X            if (obj->ox == u.ux && obj->oy == u.uy)
  439. X                if (!Punished || obj != uchain)
  440. X                    ct++;
  441. X        /* If gold is the only thing here, pick it up.
  442. X         */
  443. X        if (!ct && g_at(u.ux, u.uy)) {
  444. X            if (flags.run) nomul(0);
  445. X            while (gold = g_at(u.ux,u.uy)) {
  446. X                pline("%ld gold piece%s.", gold->amount,
  447. X                    plur(gold->amount));
  448. X                u.ugold += gold->amount;
  449. X                flags.botl = 1;
  450. X                freegold(gold);
  451. X            }
  452. X            if (Invisible) newsym(u.ux,u.uy);
  453. X        }
  454. X
  455. X        /* If there are objects here, take a look.
  456. X         */
  457. X        if (ct) {
  458. X            if (flags.run)
  459. X                nomul(0);
  460. X            nscr();
  461. X            if (ct < 5)
  462. X                dolook();
  463. X            else
  464. X                pline("There are several objects here.");
  465. X        }
  466. X        return;
  467. X    }
  468. X#endif
  469. X    while(gold = g_at(u.ux,u.uy)) {
  470. X        pline("%ld gold piece%s.", gold->amount, plur(gold->amount));
  471. X        u.ugold += gold->amount;
  472. X        flags.botl = 1;
  473. X        freegold(gold);
  474. X        if(flags.run) nomul(0);
  475. X        if(Invisible) newsym(u.ux,u.uy);
  476. X    }
  477. X    /* check for more than one object */
  478. X    if(!all) {
  479. X        register int ct = 0;
  480. X
  481. X        for(obj = fobj; obj; obj = obj->nobj)
  482. X            if(obj->ox == u.ux && obj->oy == u.uy) ct++;
  483. X        if(g_at(u.ux,u.uy))
  484. X            ct++;
  485. X        if(ct < 2)
  486. X            all++;
  487. X        else
  488. X            pline("There are several objects here.");
  489. X    }
  490. X
  491. X    /* added by GAN 10/24/86 to allow selective picking up */
  492. X    if(!all)  {
  493. X        register struct obj *otmp = fobj;
  494. X
  495. X        if(g_at(u.ux,u.uy)) ilets[iletct++] = '$';
  496. X        ilets[iletct] = 0;
  497. X        while(otmp) {
  498. X            if(!index(ilets, otmp->olet) &&
  499. X               otmp->ox == u.ux && otmp->oy == u.uy)  {
  500. X                ilets[iletct++] = otmp->olet;
  501. X                ilets[iletct] = 0;
  502. X            }
  503. X            otmp = otmp->nobj;
  504. X        }        
  505. X        if(iletct == 1)
  506. X            strcpy(buf,ilets);
  507. X        else  {
  508. X            ilets[iletct++] = ' ';
  509. X            ilets[iletct++] = 'a';
  510. X            ilets[iletct++] = 'A';
  511. X            ilets[iletct] = 0;
  512. X
  513. X            if(iletct = 3)    
  514. X            pline("What kinds of thing do you want to pick up? [%s]", ilets);
  515. X            getlin(buf);
  516. X            if(buf[0] == '\033') {
  517. X                clrlin();
  518. X                return(0);
  519. X            }
  520. X        }
  521. X        ip = buf;
  522. X        olets[0] = 0;
  523. X        while(sym = *ip++){
  524. X            /* new A function (selective all) added by
  525. X             * GAN 01/09/87
  526. X             */
  527. X            if(sym == 'A')  {
  528. X                for(oletct = 0; ilets[oletct] != ' '; oletct++)
  529. X                    olets[oletct] = ilets[oletct];
  530. X                olets[oletct] = 0;
  531. X                break;
  532. X            }
  533. X            if(sym == ' ') continue;
  534. X            if(sym == 'a') all++; else
  535. X            if(index(ilets, sym)){
  536. X                if(!index(olets, sym)){
  537. X                    olets[oletct++] = sym;
  538. X                    olets[oletct] = 0;
  539. X                }
  540. X            }
  541. X            else pline("There are no %c's here.", sym);
  542. X        }        
  543. X    }
  544. X
  545. X    if(all || index(olets,'$'))
  546. X        while(gold = g_at(u.ux,u.uy)) {
  547. X            pline("%ld gold piece%s.", gold->amount,
  548. X               plur(gold->amount));
  549. X            u.ugold += gold->amount;
  550. X            flags.botl = 1;
  551. X            freegold(gold);
  552. X            if(flags.run) nomul(0);
  553. X            if(Invis) newsym(u.ux,u.uy);
  554. X    }
  555. X
  556. X
  557. X    for(obj = fobj; obj; obj = obj2) {
  558. X        obj2 = obj->nobj;   /* perhaps obj will be picked up */
  559. X        if(obj->ox == u.ux && obj->oy == u.uy) {
  560. X        if(flags.run) nomul(0);
  561. X
  562. X        if(!all)  {
  563. X            char c;
  564. X               
  565. X            if(!index(olets,obj->olet)) continue;
  566. X 
  567. X            pline("Pick up %s ? [ynaq]", doname(obj));
  568. X            while(!index("ynaq ", (c = readchar())))
  569. X                bell();
  570. X            if(c == 'q') return;
  571. X            if(c == 'n') continue;
  572. X            if(c == 'a') all = 1;
  573. X        }
  574. X 
  575. X        if(obj->otyp == DEAD_COCKATRICE && !uarmg && u.usym != 'c') {
  576. X            pline("Touching the dead cockatrice is a fatal mistake.");
  577. X            pline("You turn to stone.");
  578. X            pline("You die...");
  579. X            killer = "cockatrice cadaver";
  580. X            done("died");
  581. X        }        
  582. X 
  583. X        if(obj->otyp == SCR_SCARE_MONSTER){
  584. X          if(!obj->spe) obj->spe = 1;
  585. X          else {
  586. X            /* Note: perhaps the 1st pickup failed: you cannot
  587. X            carry anymore, and so we never dropped it -
  588. X            lets assume that treading on it twice also
  589. X            destroys the scroll */
  590. X            pline("The scroll turns to dust as you pick it up.");
  591. X#ifdef KAA
  592. X            if(!(objects[SCR_SCARE_MONSTER].oc_name_known) &&
  593. X               !(objects[SCR_SCARE_MONSTER].oc_uname))
  594. X                docall(obj);
  595. X#endif
  596. X            delobj(obj);
  597. X            continue;
  598. X          }
  599. X        }
  600. X           
  601. X        /* do not pick up uchain */
  602. X        if(Punished && obj == uchain)
  603. X            continue;
  604. X
  605. X                  
  606. X        wt = inv_weight() + obj->owt;
  607. X        if(wt > 0) {
  608. X            if(obj->quan > 1) {
  609. X                /* see how many we can lift */
  610. X                extern struct obj *splitobj();
  611. X                int savequan = obj->quan;
  612. X                int iw = inv_weight();
  613. X                int qq;
  614. X                for(qq = 1; qq < savequan; qq++){
  615. X                    obj->quan = qq;
  616. X                    if(iw + weight(obj) > 0)
  617. X                        break;
  618. X                }
  619. X                obj->quan = savequan;
  620. X                qq--;
  621. X                /* we can carry qq of them */
  622. X                if(!qq) goto too_heavy;
  623. X            pline("You can only carry %s of the %s lying here.",
  624. X                    (qq == 1) ? "one" : "some",
  625. X                    doname(obj));
  626. X                (void) splitobj(obj, qq);
  627. X                /* note: obj2 is set already, so well never
  628. X                 * encounter the other half; if it should be
  629. X                 * otherwise then write
  630. X                 *      obj2 = splitobj(obj,qq);
  631. X                 */
  632. X                goto lift_some;
  633. X            }          
  634. X        too_heavy:
  635. X            pline("There %s %s here, but %s.",
  636. X                (obj->quan == 1) ? "is" : "are",
  637. X                doname(obj),
  638. X                !invent ? "it is too heavy for you to lift"
  639. X                /* There is no such word as "anymore". KAA */
  640. X                    : "you cannot carry any more");
  641. X            break;
  642. X        }
  643. X    lift_some:
  644. X        if(inv_cnt() >= 52) {
  645. X            pline("Your knapsack cannot accomodate any more items.");
  646. X            break;
  647. X        }
  648. X        if(wt > -5) pline("You have a little trouble lifting");
  649. X        freeobj(obj);
  650. X        if(Invisible) newsym(u.ux,u.uy);
  651. X        addtobill(obj);       /* sets obj->unpaid if necessary */
  652. X        { int pickquan = obj->quan;
  653. X          int mergquan;
  654. X#ifdef KAA
  655. X        if(!Blind) if(obj->olet != WEAPON_SYM) obj->dknown = 1;
  656. X#else
  657. X        if(!Blind) obj->dknown = 1;     /* this is done by prinv(),
  658. X                 but addinv() needs it already for merging */
  659. X#endif
  660. X        obj = addinv(obj);    /* might merge it with other objects */
  661. X          mergquan = obj->quan;
  662. X          obj->quan = pickquan; /* to fool prinv() */
  663. X        prinv(obj);
  664. X          obj->quan = mergquan;
  665. X        }
  666. X        }
  667. X    }
  668. X}
  669. X
  670. X/* stop running if we see something interesting */
  671. X/* turn around a corner if that is the only way we can proceed */
  672. X/* do not turn left or right twice */
  673. Xlookaround(){
  674. Xregister x,y,i,x0,y0,m0,i0 = 9;
  675. Xregister int corrct = 0, noturn = 0;
  676. Xregister struct monst *mtmp;
  677. X#ifdef lint
  678. X    /* suppress "used before set" message */
  679. X    x0 = y0 = 0;
  680. X#endif
  681. X    if(Blind || flags.run == 0) return;
  682. X    if(flags.run == 1 && levl[u.ux][u.uy].typ == ROOM) return;
  683. X#ifdef QUEST
  684. X    if(u.ux0 == u.ux+u.dx && u.uy0 == u.uy+u.dy) goto stop;
  685. X#endif
  686. X    for(x = u.ux-1; x <= u.ux+1; x++) for(y = u.uy-1; y <= u.uy+1; y++){
  687. X        if(x == u.ux && y == u.uy) continue;
  688. X        if(!levl[x][y].typ) continue;
  689. X        if((mtmp = m_at(x,y)) && !mtmp->mimic &&
  690. X            (!mtmp->minvis || See_invisible)){
  691. X            if(!mtmp->mtame || (x == u.ux+u.dx && y == u.uy+u.dy))
  692. X                goto stop;
  693. X        } else mtmp = 0; /* invisible M cannot influence us */
  694. X        if(x == u.ux-u.dx && y == u.uy-u.dy) continue;
  695. X#ifdef DGK
  696. X        {
  697. X        register uchar sym = levl[x][y].scrsym;
  698. X
  699. X        if (sym == symbol.vwall || sym == symbol.hwall
  700. X            || sym == symbol.room || sym == ' ' || IS_CORNER(sym))
  701. X            continue;
  702. X        else if (sym == symbol.door) {
  703. X            if(x != u.ux && y != u.uy) continue;
  704. X            if(flags.run != 1) goto stop;
  705. X            goto corr;
  706. X        } else if (sym == symbol.corr) {
  707. X        corr:
  708. X            if(flags.run == 1 || flags.run == 3) {
  709. X                i = DIST(x,y,u.ux+u.dx,u.uy+u.dy);
  710. X                if(i > 2) continue;
  711. X                if(corrct == 1 && DIST(x,y,x0,y0) != 1)
  712. X                    noturn = 1;
  713. X                if(i < i0) {
  714. X                    i0 = i;
  715. X                    x0 = x;
  716. X                    y0 = y;
  717. X                    m0 = mtmp ? 1 : 0;
  718. X                }
  719. X            }
  720. X            corrct++;
  721. X            continue;
  722. X        } else if (sym == '^') {
  723. X            if(flags.run == 1) goto corr;    /* if you must */
  724. X            if(x == u.ux+u.dx && y == u.uy+u.dy) goto stop;
  725. X            continue;
  726. X        } else {        /* e.g. objects or trap or stairs */
  727. X            if(flags.run == 1) goto corr;
  728. X            if(mtmp) continue;        /* d */
  729. X        }
  730. X        stop:
  731. X            nomul(0);
  732. X            return;
  733. X        }
  734. X#else
  735. X        switch(levl[x][y].scrsym){
  736. X        case '|':
  737. X        case '-':
  738. X        case '.':
  739. X        case ' ':
  740. X            break;
  741. X        case '+':
  742. X            if(x != u.ux && y != u.uy) break;
  743. X            if(flags.run != 1) goto stop;
  744. X            /* fall into next case */
  745. X        case CORR_SYM:
  746. X        corr:
  747. X            if(flags.run == 1 || flags.run == 3) {
  748. X                i = DIST(x,y,u.ux+u.dx,u.uy+u.dy);
  749. X                if(i > 2) break;
  750. X                if(corrct == 1 && DIST(x,y,x0,y0) != 1)
  751. X                    noturn = 1;
  752. X                if(i < i0) {
  753. X                    i0 = i;
  754. X                    x0 = x;
  755. X                    y0 = y;
  756. X                    m0 = mtmp ? 1 : 0;
  757. X                }
  758. X            }
  759. X            corrct++;
  760. X            break;
  761. X        case '^':
  762. X            if(flags.run == 1) goto corr;    /* if you must */
  763. X            if(x == u.ux+u.dx && y == u.uy+u.dy) goto stop;
  764. X            break;
  765. X        default:    /* e.g. objects or trap or stairs */
  766. X            if(flags.run == 1) goto corr;
  767. X            if(mtmp) break;        /* d */
  768. X        stop:
  769. X            nomul(0);
  770. X            return;
  771. X        }
  772. X#endif
  773. X    }
  774. X#ifdef QUEST
  775. X    if(corrct > 0 && (flags.run == 4 || flags.run == 5)) goto stop;
  776. X#endif
  777. X    if(corrct > 1 && flags.run == 2) goto stop;
  778. X    if((flags.run == 1 || flags.run == 3) && !noturn && !m0 && i0 &&
  779. X        (corrct == 1 || (corrct == 2 && i0 == 1))) {
  780. X        /* make sure that we do not turn too far */
  781. X        if(i0 == 2) {
  782. X            if(u.dx == y0-u.uy && u.dy == u.ux-x0)
  783. X            i = 2;        /* straight turn right */
  784. X            else
  785. X            i = -2;        /* straight turn left */
  786. X        } else if(u.dx && u.dy) {
  787. X            if((u.dx == u.dy && y0 == u.uy) ||
  788. X            (u.dx != u.dy && y0 != u.uy))
  789. X            i = -1;        /* half turn left */
  790. X            else
  791. X            i = 1;        /* half turn right */
  792. X        } else {
  793. X            if((x0-u.ux == y0-u.uy && !u.dy) ||
  794. X            (x0-u.ux != y0-u.uy && u.dy))
  795. X            i = 1;        /* half turn right */
  796. X            else
  797. X            i = -1;        /* half turn left */
  798. X        }
  799. X        i += u.last_str_turn;
  800. X        if(i <= 2 && i >= -2) {
  801. X            u.last_str_turn = i;
  802. X            u.dx = x0-u.ux, u.dy = y0-u.uy;
  803. X        }
  804. X    }
  805. X}
  806. X
  807. X/* something like lookaround, but we are not running */
  808. X/* react only to monsters that might hit us */
  809. Xmonster_nearby() {
  810. Xregister int x,y;
  811. Xregister struct monst *mtmp;
  812. X    if(!Blind)
  813. X    for(x = u.ux-1; x <= u.ux+1; x++) for(y = u.uy-1; y <= u.uy+1; y++){
  814. X        if(x == u.ux && y == u.uy) continue;
  815. X        if((mtmp = m_at(x,y)) && !mtmp->mimic && !mtmp->mtame &&
  816. X            !mtmp->mpeaceful && !index("Ea", mtmp->data->mlet) &&
  817. X            !mtmp->mfroz && !mtmp->msleep &&  /* aplvax!jcn */
  818. X            (!mtmp->minvis || See_invisible))
  819. X            return(1);
  820. X    }
  821. X    return(0);
  822. X}
  823. X
  824. X#ifdef QUEST
  825. Xcansee(x,y) xchar x,y; {
  826. Xregister int dx,dy,adx,ady,sdx,sdy,dmax,d;
  827. X    if(Blind) return(0);
  828. X    if(!isok(x,y)) return(0);
  829. X    d = dist(x,y);
  830. X    if(d < 3) return(1);
  831. X    if(d > u.uhorizon*u.uhorizon) return(0);
  832. X    if(!levl[x][y].lit)
  833. X        return(0);
  834. X    dx = x - u.ux;    adx = abs(dx);    sdx = sgn(dx);
  835. X    dy = y - u.uy;  ady = abs(dy);    sdy = sgn(dy);
  836. X    if(dx == 0 || dy == 0 || adx == ady){
  837. X        dmax = (dx == 0) ? ady : adx;
  838. X        for(d = 1; d <= dmax; d++)
  839. X            if(!rroom(sdx*d,sdy*d))
  840. X                return(0);
  841. X        return(1);
  842. X    } else if(ady > adx){
  843. X        for(d = 1; d <= ady; d++){
  844. X            if(!rroom(sdx*( (d*adx)/ady ), sdy*d) ||
  845. X               !rroom(sdx*( (d*adx-1)/ady+1 ), sdy*d))
  846. X                return(0);
  847. X        }
  848. X        return(1);
  849. X    } else {
  850. X        for(d = 1; d <= adx; d++){
  851. X            if(!rroom(sdx*d, sdy*( (d*ady)/adx )) ||
  852. X               !rroom(sdx*d, sdy*( (d*ady-1)/adx+1 )))
  853. X                return(0);
  854. X        }
  855. X        return(1);
  856. X    }
  857. X}
  858. X
  859. Xrroom(x,y) register int x,y; {
  860. X    return(IS_ROOM(levl[u.ux+x][u.uy+y].typ));
  861. X}
  862. X
  863. X#else
  864. X
  865. Xcansee(x,y) xchar x,y; {
  866. X    if(Blind || u.uswallow) return(0);
  867. X    if(dist(x,y) < 3) return(1);
  868. X    if(levl[x][y].lit && seelx <= x && x <= seehx && seely <= y &&
  869. X        y <= seehy) return(1);
  870. X    return(0);
  871. X}
  872. X#endif /* QUEST /**/
  873. X
  874. Xsgn(a) register int a; {
  875. X    return((a > 0) ? 1 : (a == 0) ? 0 : -1);
  876. X}
  877. X
  878. X#ifdef QUEST
  879. Xsetsee()
  880. X{
  881. X    register x,y;
  882. X
  883. X    if(Blind) {
  884. X        pru();
  885. X        return;
  886. X    }
  887. X    for(y = u.uy-u.uhorizon; y <= u.uy+u.uhorizon; y++)
  888. X        for(x = u.ux-u.uhorizon; x <= u.ux+u.uhorizon; x++) {
  889. X            if(cansee(x,y))
  890. X                prl(x,y);
  891. X    }
  892. X}
  893. X
  894. X#else
  895. X
  896. Xsetsee()
  897. X{
  898. X    register x,y;
  899. X
  900. X    if(Blind) {
  901. X        pru();
  902. X        return;
  903. X    }
  904. X    if(!levl[u.ux][u.uy].lit) {
  905. X        seelx = u.ux-1;
  906. X        seehx = u.ux+1;
  907. X        seely = u.uy-1;
  908. X        seehy = u.uy+1;
  909. X    } else {
  910. X        for(seelx = u.ux; levl[seelx-1][u.uy].lit; seelx--);
  911. X        for(seehx = u.ux; levl[seehx+1][u.uy].lit; seehx++);
  912. X        for(seely = u.uy; levl[u.ux][seely-1].lit; seely--);
  913. X        for(seehy = u.uy; levl[u.ux][seehy+1].lit; seehy++);
  914. X    }
  915. X    for(y = seely; y <= seehy; y++)
  916. X        for(x = seelx; x <= seehx; x++) {
  917. X            prl(x,y);
  918. X    }
  919. X    if(!levl[u.ux][u.uy].lit) seehx = 0; /* seems necessary elsewhere */
  920. X    else {
  921. X        if(seely == u.uy) for(x = u.ux-1; x <= u.ux+1; x++) prl(x,seely-1);
  922. X        if(seehy == u.uy) for(x = u.ux-1; x <= u.ux+1; x++) prl(x,seehy+1);
  923. X        if(seelx == u.ux) for(y = u.uy-1; y <= u.uy+1; y++) prl(seelx-1,y);
  924. X        if(seehx == u.ux) for(y = u.uy-1; y <= u.uy+1; y++) prl(seehx+1,y);
  925. X    }
  926. X}
  927. X#endif /* QUEST /**/
  928. X
  929. Xnomul(nval)
  930. Xregister nval;
  931. X{
  932. X#ifdef DGKMOD
  933. X    if(multi < nval) return;    /* This is a bug fix by ab@unido */
  934. X#else
  935. X    if(multi < 0) return;
  936. X#endif
  937. X    multi = nval;
  938. X    flags.mv = flags.run = 0;
  939. X}
  940. X
  941. Xabon()
  942. X{
  943. X#ifdef KAA
  944. X    if (u.usym != '@') return(mons[u.umonnum].mlevel-3);
  945. X#endif
  946. X    if(u.ustr == 3) return(-3);
  947. X    else if(u.ustr < 6) return(-2);
  948. X    else if(u.ustr < 8) return(-1);
  949. X    else if(u.ustr < 17) return(0);
  950. X    else if(u.ustr < 69) return(1);    /* up to 18/50 */
  951. X    else if(u.ustr < 118) return(2);
  952. X    else return(3);
  953. X}
  954. X
  955. Xdbon()
  956. X{
  957. X    if (u.usym != '@') return(0);
  958. X
  959. X    if(u.ustr < 6) return(-1);
  960. X    else if(u.ustr < 16) return(0);
  961. X    else if(u.ustr < 18) return(1);
  962. X    else if(u.ustr == 18) return(2);    /* up to 18 */
  963. X    else if(u.ustr < 94) return(3);        /* up to 18/75 */
  964. X    else if(u.ustr < 109) return(4);    /* up to 18/90 */
  965. X    else if(u.ustr < 118) return(5);    /* up to 18/99 */
  966. X    else return(6);
  967. X}
  968. X
  969. Xlosestr(num)    /* may kill you; cause may be poison or monster like 'A' */
  970. Xregister num;
  971. X{
  972. X    u.ustr -= num;
  973. X    while(u.ustr < 3) {
  974. X        u.ustr++;
  975. X        u.uhp -= 6;
  976. X        u.uhpmax -= 6;
  977. X    }
  978. X    flags.botl = 1;
  979. X}
  980. X
  981. Xlosehp(n,knam)
  982. Xregister n;
  983. Xregister char *knam;
  984. X{
  985. X#ifdef KAA
  986. X    if (u.mtimedone) {
  987. X        u.mh -= n;
  988. X        if (u.mhmax < u.mh) u.mhmax = u.mh;
  989. X        flags.botl = 1;
  990. X        if (u.mh < 1) rehumanize();
  991. X        return(0);
  992. X    }
  993. X#endif
  994. X    u.uhp -= n;
  995. X    if(u.uhp > u.uhpmax)
  996. X        u.uhpmax = u.uhp;    /* perhaps n was negative */
  997. X    flags.botl = 1;
  998. X    if(u.uhp < 1) {
  999. X        killer = knam;    /* the thing that killed you */
  1000. X        pline("you died");
  1001. X        done("died");
  1002. X    }
  1003. X}
  1004. X
  1005. Xlosehp_m(n,mtmp)
  1006. Xregister n;
  1007. Xregister struct monst *mtmp;
  1008. X{
  1009. X#ifdef KAA
  1010. X    if (u.mtimedone) {
  1011. X        u.mh -= n;
  1012. X        flags.botl = 1;
  1013. X        if (u.mh < 1) rehumanize();
  1014. X        return;
  1015. X    }
  1016. X#endif
  1017. X    u.uhp -= n;
  1018. X    flags.botl = 1;
  1019. X    if(u.uhp < 1)
  1020. X        done_in_by(mtmp);
  1021. X}
  1022. X
  1023. Xlosexp()    /* hit by V or W */
  1024. X{
  1025. X    register num;
  1026. X    extern long newuexp();
  1027. X
  1028. X    if (u.usym == 'V' || u.usym=='W') return;
  1029. X
  1030. X    if(u.ulevel > 1)
  1031. X        pline("Goodbye level %u.", u.ulevel--);
  1032. X    else
  1033. X        u.uhp = -1;
  1034. X    num = rnd(10);
  1035. X    u.uhp -= num;
  1036. X    u.uhpmax -= num;
  1037. X#ifdef SPELLS
  1038. X    num = rnd(u.ulevel/2+1) + 1;        /* M. Stephenson */
  1039. X    u.uen -= num;
  1040. X    if (u.uen < 0)        u.uen = 0;
  1041. X    u.uenmax -= num;
  1042. X    if (u.uenmax < 0)    u.uenmax = 0;
  1043. X#endif
  1044. X    u.uexp = newuexp();
  1045. X    flags.botl = 1;
  1046. X}
  1047. X
  1048. Xinv_weight(){
  1049. Xregister struct obj *otmp = invent;
  1050. Xregister int wt = (u.ugold + 500)/1000;
  1051. Xregister int carrcap;
  1052. X#ifdef KAA
  1053. X    if (u.mtimedone) {
  1054. X        if (u.usym == '9') carrcap = MAX_CARR_CAP * 4;
  1055. X        else if (u.usym == 'N') carrcap = MAX_CARR_CAP;
  1056. X        else if (mons[u.umonnum].mlevel <= 3)
  1057. X            carrcap = 5*mons[u.umonnum].mlevel + 30;
  1058. X        else carrcap = 5*mons[u.umonnum].mlevel + 100;
  1059. X    }
  1060. X#endif
  1061. X    if(Levitation)            /* pugh@cornell */
  1062. X        carrcap = MAX_CARR_CAP;
  1063. X    else {
  1064. X        carrcap = 5*(((u.ustr > 18) ? 20 : u.ustr) + u.ulevel);
  1065. X        if(carrcap > MAX_CARR_CAP) carrcap = MAX_CARR_CAP;
  1066. X        if(Wounded_legs & LEFT_SIDE) carrcap -= 10;
  1067. X        if(Wounded_legs & RIGHT_SIDE) carrcap -= 10;
  1068. X    }
  1069. X    while(otmp){
  1070. X        wt += otmp->owt;
  1071. X        otmp = otmp->nobj;
  1072. X    }
  1073. X    return(wt - carrcap);
  1074. X}
  1075. X
  1076. Xinv_cnt(){
  1077. Xregister struct obj *otmp = invent;
  1078. Xregister int ct = 0;
  1079. X    while(otmp){
  1080. X        ct++;
  1081. X        otmp = otmp->nobj;
  1082. X    }
  1083. X    return(ct);
  1084. X}
  1085. X
  1086. Xlong
  1087. Xnewuexp()
  1088. X{
  1089. X    return(10*(1L << (u.ulevel-1)));
  1090. X}
  1091. END_OF_hack.c
  1092. if test 24139 -ne `wc -c <hack.c`; then
  1093.     echo shar: \"hack.c\" unpacked with wrong size!
  1094. fi
  1095. # end of overwriting check
  1096. fi
  1097. if test -f wield.c -a "${1}" != "-c" ; then 
  1098.   echo shar: Will not over-write existing file \"wield.c\"
  1099. else
  1100. echo shar: Extracting \"wield.c\" \(3307 characters\)
  1101. sed "s/^X//" >wield.c <<'END_OF_wield.c'
  1102. X/*    SCCS Id: @(#)wield.c    1.3    87/07/14
  1103. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1104. X/* wield.c - version 1.0.3 */
  1105. X
  1106. X#include    "hack.h"
  1107. Xextern struct obj zeroobj;
  1108. Xextern char *hcolor();
  1109. X#ifdef KAA
  1110. Xextern boolean unweapon;
  1111. X#endif
  1112. X
  1113. Xsetuwep(obj) register struct obj *obj; {
  1114. X    setworn(obj, W_WEP);
  1115. X}
  1116. X
  1117. Xdowield()
  1118. X{
  1119. X    register struct obj *wep;
  1120. X    register int res = 0;
  1121. X
  1122. X    multi = 0;
  1123. X#ifdef KAA
  1124. X    if (cantwield(u.usym)) {
  1125. X        pline("Don't be ridiculous!");
  1126. X        return(0);
  1127. X    }
  1128. X#endif
  1129. X    if(!(wep = getobj("#-)", "wield"))) /* nothing */;
  1130. X    else if(uwep == wep)
  1131. X        pline("You are already wielding that!");
  1132. X    else if(welded(uwep))
  1133. X        pline("The %s welded to your hand!",
  1134. X            aobjnam(uwep, "are"));
  1135. X    else if(wep == &zeroobj) {
  1136. X        if(uwep == 0){
  1137. X            pline("You are already empty handed.");
  1138. X        } else {
  1139. X            setuwep((struct obj *) 0);
  1140. X            res++;
  1141. X            pline("You are empty handed.");
  1142. X        }
  1143. X    /* Prevent wielding a cockatrice in pack when not wearing gloves KAA*/
  1144. X    } else if (!uarmg && wep->otyp == DEAD_COCKATRICE) {
  1145. X        pline("You wield the dead cockatrice in your bare hands.");
  1146. X        pline("You turn to stone ...");
  1147. X        killer="dead cockatrice";
  1148. X        done("died");
  1149. X    } else if(uarms && wep->otyp == TWO_HANDED_SWORD)
  1150. X    pline("You cannot wield a two-handed sword and wear a shield.");
  1151. X    else if(wep->owornmask & (W_ARMOR | W_RING))
  1152. X        pline("You cannot wield that!");
  1153. X    else {
  1154. X        setuwep(wep);
  1155. X        res++;
  1156. X        if(welded(uwep))
  1157. X            pline("The %s %s to your hand!",
  1158. X            aobjnam(uwep, "weld"),
  1159. X            (uwep->quan == 1) ? "itself" : "themselves"); /* a3 */
  1160. X        else prinv(uwep);
  1161. X    }
  1162. X#ifdef KAA
  1163. X    if(res && uwep)
  1164. X        unweapon = (uwep->otyp >= BOW || uwep->otyp <= BOOMERANG) ? 
  1165. X        TRUE : FALSE;
  1166. X#endif
  1167. X    return(res);
  1168. X}
  1169. X
  1170. Xcorrode_weapon(){
  1171. X    if(!uwep || uwep->olet != WEAPON_SYM) return;    /* %% */
  1172. X    if(uwep->rustfree)
  1173. X        pline("Your %s not affected.", aobjnam(uwep, "are"));
  1174. X    else {
  1175. X        pline("Your %s!", aobjnam(uwep, "corrode"));
  1176. X        uwep->spe--;
  1177. X    }
  1178. X}
  1179. X
  1180. Xchwepon(otmp,amount)
  1181. Xregister struct obj *otmp;
  1182. Xregister amount;
  1183. X{
  1184. Xregister char *color = (amount < 0) ? "black" : "green";
  1185. Xregister char *time;
  1186. X
  1187. X    if(Hallucination) color=hcolor();
  1188. X    if(!uwep || uwep->olet != WEAPON_SYM) {
  1189. X        strange_feeling(otmp,
  1190. X            (amount > 0) ? "Your hands twitch."
  1191. X                     : "Your hands itch.");
  1192. X        return(0);
  1193. X    }
  1194. X
  1195. X    if(uwep->otyp == WORM_TOOTH && amount > 0) {
  1196. X        uwep->otyp = CRYSKNIFE;
  1197. X        pline("Your weapon seems sharper now.");
  1198. X        uwep->cursed = 0;
  1199. X        return(1);
  1200. X    }
  1201. X
  1202. X    if(uwep->otyp == CRYSKNIFE && amount < 0) {
  1203. X        uwep->otyp = WORM_TOOTH;
  1204. X        pline("Your weapon looks duller now.");
  1205. X        return(1);
  1206. X    }
  1207. X
  1208. X    /* there is a (soft) upper limit to uwep->spe */
  1209. X    if(amount > 0 && uwep->spe > 5 && rn2(3)) {
  1210. X        pline("Your %s violently %s for a while and then evaporate%s.",
  1211. X        aobjnam(uwep,"glow"),Hallucination ? hcolor() : "green",
  1212. X        plur(uwep->quan));
  1213. X
  1214. X        while(uwep)        /* let all of them disappear */
  1215. X                /* note: uwep->quan = 1 is nogood if unpaid */
  1216. X        useup(uwep);
  1217. X        return(1);
  1218. X    }
  1219. X    if(!rn2(6)) amount *= 2;
  1220. X    time = (amount*amount == 1) ? "moment" : "while";
  1221. X    pline("Your %s %s for a %s.",
  1222. X        aobjnam(uwep, "glow"), color, time);
  1223. X    uwep->spe += amount;
  1224. X    if(amount > 0) uwep->cursed = 0;
  1225. X    return(1);
  1226. X}
  1227. X
  1228. Xint
  1229. Xwelded(obj) register struct obj *obj;  {
  1230. X    return(obj == uwep && obj->cursed &&
  1231. X           (obj->olet == WEAPON_SYM || obj->otyp == HEAVY_IRON_BALL ||
  1232. X        obj->otyp == CAN_OPENER || obj->otyp == PICK_AXE));
  1233. X}
  1234. END_OF_wield.c
  1235. if test 3307 -ne `wc -c <wield.c`; then
  1236.     echo shar: \"wield.c\" unpacked with wrong size!
  1237. fi
  1238. # end of overwriting check
  1239. fi
  1240. if test -f zap.c -a "${1}" != "-c" ; then 
  1241.   echo shar: Will not over-write existing file \"zap.c\"
  1242. else
  1243. echo shar: Extracting \"zap.c\" \(23766 characters\)
  1244. sed "s/^X//" >zap.c <<'END_OF_zap.c'
  1245. X/*    SCCS Id: @(#)zap.c    1.3    87/07/14
  1246. X/* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  1247. X/* zap.c - version 1.0.3 */
  1248. X
  1249. X#include "hack.h"
  1250. X
  1251. Xextern struct obj *mkobj_at();
  1252. Xextern struct monst *makemon(), *mkmon_at(), youmonst;
  1253. Xstruct monst *bhit();
  1254. Xchar *exclam();
  1255. X#ifdef KAA
  1256. Xextern char *xname();
  1257. X#endif
  1258. X
  1259. Xchar *fl[]= {
  1260. X    "magic missile",
  1261. X    "bolt of fire",
  1262. X    "sleep ray",
  1263. X    "bolt of cold",
  1264. X    "death ray",
  1265. X    "magic missle",        /* Spell equivalents of above wands */
  1266. X    "fireball",
  1267. X    "sleep ray",
  1268. X    "cone of cold",
  1269. X    "finger of death"
  1270. X};
  1271. X
  1272. X/* Routines for IMMEDIATE wands and spells. */
  1273. X/* bhitm: monster mtmp was hit by the effect of wand or spell otmp */
  1274. Xbhitm(mtmp, otmp)
  1275. Xregister struct monst *mtmp;
  1276. Xregister struct obj *otmp;
  1277. X{
  1278. X    wakeup(mtmp);
  1279. X    switch(otmp->otyp) {
  1280. X    case WAN_STRIKING:
  1281. X#ifdef SPELLS
  1282. X    case SPE_FORCE_BOLT:
  1283. X#endif
  1284. X        if(u.uswallow || rnd(20) < 10+mtmp->data->ac) {
  1285. X            register int tmp = d(2,12);
  1286. X            hit((otmp->otyp == WAN_STRIKING) ? "wand" : "spell", mtmp, exclam(tmp));
  1287. X            resist(mtmp, otmp->olet, tmp, TELL);
  1288. X        } else miss((otmp->otyp == WAN_STRIKING) ? "wand" : "spell", mtmp);
  1289. X        break;
  1290. X    case WAN_SLOW_MONSTER:
  1291. X#ifdef SPELLS
  1292. X    case SPE_SLOW_MONSTER:
  1293. X#endif
  1294. X        if(! resist(mtmp, otmp->olet, 0, NOTELL))
  1295. X            mtmp->mspeed = MSLOW;
  1296. X        break;
  1297. X    case WAN_SPEED_MONSTER:
  1298. X        if (!resist(mtmp, otmp->olet, 0, NOTELL))
  1299. X            mtmp->mspeed = MFAST;
  1300. X        break;
  1301. X    case WAN_UNDEAD_TURNING:
  1302. X#ifdef SPELLS
  1303. X    case SPE_TURN_UNDEAD:
  1304. X#endif
  1305. X        if(index(UNDEAD,mtmp->data->mlet)) {
  1306. X
  1307. X            if(!resist(mtmp, otmp->olet, rnd(8), NOTELL))
  1308. X                mtmp->mflee = 1;
  1309. X        }
  1310. X        break;
  1311. X    case WAN_POLYMORPH:
  1312. X#ifdef SPELLS
  1313. X    case SPE_POLYMORPH:
  1314. X#endif
  1315. X        if(!resist(mtmp, otmp->olet, 0, NOTELL))
  1316. X            if( newcham(mtmp,&mons[rn2(CMNUM)]) )
  1317. X            if (!Hallucination)
  1318. X                objects[otmp->otyp].oc_name_known = 1;
  1319. X        break;
  1320. X    case WAN_CANCELLATION:
  1321. X#ifdef SPELLS
  1322. X    case SPE_CANCELLATION:
  1323. X#endif
  1324. X        if(!resist(mtmp, otmp->olet, 0, NOTELL))
  1325. X            mtmp->mcan = 1;
  1326. X        break;
  1327. X    case WAN_TELEPORTATION:
  1328. X#ifdef SPELLS
  1329. X    case SPE_TELEPORT_AWAY:
  1330. X#endif
  1331. X        rloc(mtmp);
  1332. X        break;
  1333. X    case WAN_MAKE_INVISIBLE:
  1334. X        mtmp->minvis = 1;
  1335. X        break;
  1336. X    case WAN_NOTHING:
  1337. X        break;
  1338. X    case WAN_PROBING:
  1339. X#ifdef PROBING
  1340. X        mstatusline(mtmp);
  1341. X#else
  1342. X        pline("Nothing Happens.");
  1343. X#endif
  1344. X        break;
  1345. X    default:
  1346. X        impossible("What an interesting effect (%u)", otmp->otyp);
  1347. X    }
  1348. X}
  1349. X
  1350. Xbhito(obj, otmp)    /* object obj was hit by the effect of wand otmp */
  1351. Xregister struct obj *obj, *otmp;    /* returns TRUE if sth was done */
  1352. X{
  1353. X    register int res = TRUE;
  1354. X#ifdef DGKMOD
  1355. X    struct obj *otmp2;
  1356. X#endif
  1357. X
  1358. X    if(obj == uball || obj == uchain)
  1359. X        res = FALSE;
  1360. X    else
  1361. X    switch(otmp->otyp) {
  1362. X    case WAN_POLYMORPH:
  1363. X#ifdef SPELLS
  1364. X    case SPE_POLYMORPH:
  1365. X#endif
  1366. X        /* preserve symbol and quantity, but turn rocks into gems */
  1367. X#ifdef DGKMOD
  1368. X        otmp2 = mkobj_at((obj->otyp == ROCK
  1369. X            || obj->otyp == ENORMOUS_ROCK) ? GEM_SYM : obj->olet,
  1370. X            obj->ox, obj->oy);
  1371. X        otmp2->quan = obj->quan;
  1372. X        /* keep special fields (including charges on wands) */
  1373. X        /* The DGK modification doesn't allow polymorphing a weapon
  1374. X           with enchantments into another one, and doesn't allow 
  1375. X           polymorphed rings to have plusses.  KAA*/
  1376. X        if (index("/)[", otmp2->olet)) otmp2->spe = obj->spe;
  1377. X        otmp2->cursed = otmp->cursed;
  1378. X        /* update the weight */
  1379. X        otmp2->owt = weight(otmp2);
  1380. X#else
  1381. X        mkobj_at((obj->otyp == ROCK || obj->otyp == ENORMOUS_ROCK)
  1382. X            ? GEM_SYM : obj->olet,
  1383. X            obj->ox, obj->oy) -> quan = obj->quan;
  1384. X#endif
  1385. X        delobj(obj);
  1386. X        break;
  1387. X    case WAN_STRIKING:
  1388. X#ifdef SPELLS
  1389. X    case SPE_FORCE_BOLT:
  1390. X#endif
  1391. X        if(obj->otyp == ENORMOUS_ROCK)
  1392. X            fracture_rock(obj);
  1393. X        else
  1394. X            res = FALSE;
  1395. X        break;
  1396. X    case WAN_CANCELLATION:
  1397. X#ifdef SPELLS
  1398. X    case SPE_CANCELLATION:
  1399. X#endif
  1400. X        if(obj->spe && obj->olet != AMULET_SYM) {
  1401. X            obj->known = 0;
  1402. X            obj->spe = 0;
  1403. X        }
  1404. X        break;
  1405. X    case WAN_TELEPORTATION:
  1406. X#ifdef SPELLS
  1407. X    case SPE_TELEPORT_AWAY:
  1408. X#endif
  1409. X        rloco(obj);
  1410. X        break;
  1411. X    case WAN_MAKE_INVISIBLE:
  1412. X        obj->oinvis = 1;
  1413. X        break;
  1414. X    case WAN_UNDEAD_TURNING:
  1415. X#ifdef SPELLS
  1416. X    case SPE_TURN_UNDEAD:
  1417. X#endif
  1418. X        res = revive(obj);
  1419. X        break;
  1420. X    case WAN_SLOW_MONSTER:        /* no effect on objects */
  1421. X#ifdef SPELLS
  1422. X    case SPE_SLOW_MONSTER:
  1423. X#endif
  1424. X    case WAN_SPEED_MONSTER:
  1425. X    case WAN_NOTHING:
  1426. X    case WAN_PROBING:
  1427. X        res = FALSE;
  1428. X        break;
  1429. X    default:
  1430. X        impossible("What an interesting effect (%u)", otmp->otyp);
  1431. X    }
  1432. X    return(res);
  1433. X}
  1434. X
  1435. X/*
  1436. X * zappable - returns 1 if zap is available, 0 otherwise.
  1437. X *          it removes a charge from the wand if zappable.
  1438. X * added by GAN 11/03/86
  1439. X */
  1440. Xint
  1441. Xzappable(wand)
  1442. Xregister struct obj *wand;
  1443. X{
  1444. X    if(wand->spe < 0 || (wand->spe ==0 && rn2(121)))
  1445. X        return(0);
  1446. X    else  {
  1447. X        if(wand->spe == 0)
  1448. X            pline("You wrest one more spell from the worn-out wand.");
  1449. X        wand->spe--;
  1450. X        return(1);
  1451. X    }
  1452. X}
  1453. X
  1454. X/*
  1455. X * zapnodir - zaps an NODIR wand.
  1456. X * added by GAN 11/03/86
  1457. X */
  1458. Xzapnodir(wand)
  1459. Xregister struct obj *wand;
  1460. X{
  1461. X    switch(wand->otyp){
  1462. X        case WAN_LIGHT:
  1463. X            litroom(TRUE);
  1464. X            break;
  1465. X        case WAN_SECRET_DOOR_DETECTION:
  1466. X            if(!findit()) return(1);
  1467. X            break;
  1468. X        case WAN_CREATE_MONSTER:
  1469. X            { register int cnt = 1;
  1470. X            if(!rn2(23)) cnt += rn2(7) + 1;
  1471. X            while(cnt--)
  1472. X                (void) makemon((struct permonst *) 0, u.ux, u.uy);
  1473. X            }
  1474. X            break;
  1475. X        case WAN_WISHING:
  1476. X              
  1477. X            if(u.uluck + rn2(5) < 0) {
  1478. X                pline("Unfortunately, nothing happens.");
  1479. X                break;
  1480. X            }
  1481. X            makewish();
  1482. X            break;
  1483. X    }
  1484. X    if(!objects[wand->otyp].oc_name_known) {
  1485. X            objects[wand->otyp].oc_name_known = 1;
  1486. X            more_experienced(0,10);
  1487. X    }
  1488. X}
  1489. X
  1490. Xdozap()
  1491. X{
  1492. X    register struct obj *obj;
  1493. X    int    damage;
  1494. X
  1495. X    obj = getobj("/", "zap");
  1496. X    if(!obj) return(0);
  1497. X    
  1498. X    /* zappable addition done by GAN 11/03/86 */
  1499. X    if(!zappable(obj))  {
  1500. X        pline("Nothing Happens.");
  1501. X        return(1);
  1502. X    }
  1503. X    if(!(objects[obj->otyp].bits & NODIR) && !getdir(1)) {
  1504. X        pline("The %s glows and fades.",xname(obj));
  1505. X        return(1);    /* make him pay for knowing !NODIR */
  1506. X    }
  1507. X#ifdef KAA
  1508. X     if(!u.dx && !u.dy && !u.dz && !(objects[obj->otyp].bits & NODIR)) {
  1509. X
  1510. X        if((damage = zapyourself(obj)))
  1511. X            losehp(damage,"self-inflicted injury");
  1512. X        return(1);
  1513. X     }
  1514. X#endif
  1515. X    weffects(obj);
  1516. X    return(1);
  1517. X}
  1518. X
  1519. X#ifdef KAA
  1520. X#define    makeknown(x)    objects[x].oc_name_known = 1
  1521. X
  1522. Xzapyourself(obj)
  1523. X    register struct obj    *obj;
  1524. X{
  1525. Xstruct obj    *otmp;
  1526. Xint    damage = 0;
  1527. X
  1528. X      switch(obj->otyp) {
  1529. X           case WAN_STRIKING:
  1530. X            damage=d(8,6);
  1531. X            pline("The wand hits you!");
  1532. X            break;
  1533. X           case WAN_FIRE:
  1534. X            if (!Fire_resistance) damage=d(12,6);
  1535. X            pline("The wand sprays you with flames!");
  1536. X            makeknown(WAN_FIRE);
  1537. X            burn_scrolls();
  1538. X            boil_potions();
  1539. X            break;
  1540. X           case WAN_COLD:
  1541. X            if (!Cold_resistance) damage=d(12,6);
  1542. X            pline("You are blasted with liquid nitrogen!");
  1543. X            makeknown(WAN_COLD);
  1544. X            break;
  1545. X           case WAN_MAGIC_MISSILE:
  1546. X            damage = d(4,6);
  1547. X            pline("You are shot at point blank range!");
  1548. X            makeknown(WAN_MAGIC_MISSILE);
  1549. X            break;
  1550. X           case WAN_POLYMORPH:
  1551. X            makeknown(WAN_POLYMORPH);
  1552. X            polyself();
  1553. X            break;
  1554. X           case WAN_CANCELLATION:
  1555. X            for(otmp = invent; otmp; otmp = otmp->nobj)
  1556. X               if(otmp != uball && otmp->otyp != AMULET_OF_YENDOR)
  1557. X                  otmp->spe = 0;
  1558. X            if(u.mtimedone) rehumanize();
  1559. X            flags.botl = 1;  /* because of potential AC change */
  1560. X            find_ac();
  1561. X            break;
  1562. X           case WAN_MAKE_INVISIBLE:
  1563. X            HInvis |= INTRINSIC;
  1564. X            /* Tough luck if you cannot see invisible! */
  1565. X            if (!See_invisible) newsym(u.ux, u.uy);
  1566. X            break;
  1567. X           case WAN_SPEED_MONSTER:
  1568. X            Fast |= INTRINSIC;
  1569. X            break;
  1570. X           case WAN_SLEEP:
  1571. X            makeknown(WAN_SLEEP);
  1572. X            pline("The sleep ray hits you!");
  1573. X            nomul(-rn2(50));
  1574. X            break;
  1575. X           case WAN_SLOW_MONSTER:
  1576. X            Fast = 0;
  1577. X            break;
  1578. X           case WAN_TELEPORTATION:
  1579. X            tele();
  1580. X            break;
  1581. X           case WAN_DEATH:
  1582. X            pline("You irradiate yourself with pure energy!");
  1583. X            pline("You die.");
  1584. X            killer = "wand of death";
  1585. X            done("died");
  1586. X            break;
  1587. X           case WAN_DIGGING:
  1588. X           case WAN_UNDEAD_TURNING:
  1589. X           case WAN_NOTHING:
  1590. X            break;
  1591. X           default: impossible("object %d zap?",obj->otyp);
  1592. X      }
  1593. X    return(damage);
  1594. X}
  1595. X#endif /* KAA /**/
  1596. X
  1597. X/* called for various wand and spell effects - M. Stephenson */
  1598. Xweffects(obj)
  1599. X    register struct    obj    *obj;
  1600. X{
  1601. X    xchar zx,zy;
  1602. X
  1603. X    if(objects[obj->otyp].bits & IMMEDIATE) {
  1604. X        if(u.uswallow)
  1605. X            bhitm(u.ustuck, obj);
  1606. X        else if(u.dz) {
  1607. X            if(u.dz > 0 && o_at(u.ux,u.uy)) {
  1608. X                register struct obj *otmp;
  1609. X                
  1610. X                /* changed by GAN to hit all objects there */
  1611. X                for(otmp = fobj; otmp ; otmp = otmp->nobj)
  1612. X                    if(otmp->ox == u.ux &&
  1613. X                       otmp->oy == u.uy)
  1614. X                        (void) bhito(otmp, obj);
  1615. X            }
  1616. X        } else
  1617. X            (void) bhit(u.dx,u.dy,rn1(8,6),0,bhitm,bhito,obj);
  1618. X    } else {
  1619. X        switch(obj->otyp){
  1620. X        case WAN_LIGHT:
  1621. X#ifdef SPELLS
  1622. X        case SPE_LIGHT:
  1623. X#endif
  1624. X            litroom(TRUE);
  1625. X            break;
  1626. X        case WAN_SECRET_DOOR_DETECTION:
  1627. X#ifdef SPELLS
  1628. X        case SPE_DETECT_UNSEEN:
  1629. X#endif
  1630. X            if(!findit()) return(1);
  1631. X            break;
  1632. X        case WAN_CREATE_MONSTER:
  1633. X            { register int cnt = 1;
  1634. X            if(!rn2(23)) cnt += rn2(7) + 1;
  1635. X            while(cnt--)
  1636. X                (void) makemon((struct permonst *) 0, u.ux, u.uy);
  1637. X            }
  1638. X            break;
  1639. X        case WAN_WISHING:
  1640. X            if(u.uluck + rn2(5) < 0) {
  1641. X                pline("Unfortunately, nothing happens.");
  1642. X                break;
  1643. X            }
  1644. X            makewish();
  1645. X            break;
  1646. X        case WAN_DIGGING:
  1647. X#ifdef SPELLS
  1648. X        case SPE_DIG:
  1649. X#endif
  1650. X            /* Original effect (approximately):
  1651. X             * from CORR: dig until we pierce a wall
  1652. X             * from ROOM: piece wall and dig until we reach
  1653. X             * an ACCESSIBLE place.
  1654. X             * Currently: dig for digdepth positions;
  1655. X             * also down on request of Lennart Augustsson.
  1656. X             */
  1657. X            { register struct rm *room;
  1658. X              register int digdepth;
  1659. X            if(u.uswallow) {
  1660. X                register struct monst *mtmp = u.ustuck;
  1661. X
  1662. X                pline("You pierce %s's stomach wall!",
  1663. X                    monnam(mtmp));
  1664. X                mtmp->mhp = 1;    /* almost dead */
  1665. X                unstuck(mtmp);
  1666. X                mnexto(mtmp);
  1667. X                break;
  1668. X            }
  1669. X            if(u.dz) {
  1670. X                if(u.dz < 0) {
  1671. X                pline("You loosen a rock from the ceiling.");
  1672. X                pline("It falls on your head!");
  1673. X                losehp(1, "falling rock");
  1674. X                mksobj_at(ROCK, u.ux, u.uy);
  1675. X                fobj->quan = 1;
  1676. X                stackobj(fobj);
  1677. X                if(Invisible) newsym(u.ux, u.uy);
  1678. X                } else {
  1679. X                dighole();
  1680. X                }
  1681. X                break;
  1682. X            }
  1683. X            zx = u.ux+u.dx;
  1684. X            zy = u.uy+u.dy;
  1685. X            digdepth = 8 + rn2(18);
  1686. X            Tmp_at(-1, '*');    /* open call */
  1687. X            while(--digdepth >= 0) {
  1688. X                if(!isok(zx,zy)) break;
  1689. X                room = &levl[zx][zy];
  1690. X                Tmp_at(zx,zy);
  1691. X                if(!xdnstair){
  1692. X                    if(zx < 3 || zx > COLNO-3 ||
  1693. X                        zy < 3 || zy > ROWNO-3)
  1694. X                        break;
  1695. X                    if(room->typ == HWALL ||
  1696. X                        room->typ == VWALL){
  1697. X                        room->typ = ROOM;
  1698. X                        break;
  1699. X                    }
  1700. X                } else
  1701. X                if(room->typ == HWALL || room->typ == VWALL ||
  1702. X                   room->typ == SDOOR || room->typ == LDOOR){
  1703. X                    room->typ = DOOR;
  1704. X                    digdepth -= 2;
  1705. X                } else
  1706. X                if(room->typ == SCORR || !room->typ) {
  1707. X                    room->typ = CORR;
  1708. X                    digdepth--;
  1709. X                }
  1710. X                mnewsym(zx,zy);
  1711. X                zx += u.dx;
  1712. X                zy += u.dy;
  1713. X            }
  1714. X            mnewsym(zx,zy);    /* not always necessary */
  1715. X            Tmp_at(-1,-1);    /* closing call */
  1716. X            break;
  1717. X            }
  1718. X        default:
  1719. X#ifdef SPELLS
  1720. X            if((int) obj->otyp >= SPE_MAGIC_MISSILE) {
  1721. X
  1722. X                buzz((int) obj->otyp - SPE_MAGIC_MISSILE + 5,
  1723. X                    u.ux, u.uy, u.dx, u.dy);
  1724. X            } else
  1725. X#endif
  1726. X
  1727. X                buzz((int) obj->otyp - WAN_MAGIC_MISSILE,
  1728. X                    u.ux, u.uy, u.dx, u.dy);
  1729. X            break;
  1730. X        }
  1731. X        if(!objects[obj->otyp].oc_name_known) {
  1732. X            objects[obj->otyp].oc_name_known = 1;
  1733. X            more_experienced(0,10);
  1734. X        }
  1735. X    }
  1736. X    return;
  1737. X}
  1738. X
  1739. Xchar *
  1740. Xexclam(force)
  1741. Xregister int force;
  1742. X{
  1743. X    /* force == 0 occurs e.g. with sleep ray */
  1744. X    /* note that large force is usual with wands so that !! would
  1745. X        require information about hand/weapon/wand */
  1746. X    return( (force < 0) ? "?" : (force <= 4) ? "." : "!" );
  1747. X}
  1748. X
  1749. Xhit(str,mtmp,force)
  1750. Xregister char *str;
  1751. Xregister struct monst *mtmp;
  1752. Xregister char *force;        /* usually either "." or "!" */
  1753. X{
  1754. X    if(!cansee(mtmp->mx,mtmp->my)) pline("The %s hits it.", str);
  1755. X    else pline("The %s hits %s%s", str, monnam(mtmp), force);
  1756. X}
  1757. X
  1758. Xmiss(str,mtmp)
  1759. Xregister char *str;
  1760. Xregister struct monst *mtmp;
  1761. X{
  1762. X    if(!cansee(mtmp->mx,mtmp->my)) pline("The %s misses it.",str);
  1763. X    else pline("The %s misses %s.",str,monnam(mtmp));
  1764. X}
  1765. X
  1766. X/* bhit: called when a weapon is thrown (sym = obj->olet) or when an
  1767. X   IMMEDIATE wand is zapped (sym = 0); the weapon falls down at end of
  1768. X   range or when a monster is hit; the monster is returned, and bhitpos
  1769. X   is set to the final position of the weapon thrown; the ray of a wand
  1770. X   may affect several objects and monsters on its path - for each of
  1771. X   these an argument function is called. */
  1772. X/* check !u.uswallow before calling bhit() */
  1773. X
  1774. Xstruct monst *
  1775. Xbhit(ddx,ddy,range,sym,fhitm,fhito,obj)
  1776. Xregister int ddx,ddy,range;        /* direction and range */
  1777. Xchar sym;                /* symbol displayed on path */
  1778. Xint (*fhitm)(), (*fhito)();        /* fns called when mon/obj hit */
  1779. Xstruct obj *obj;            /* 2nd arg to fhitm/fhito */
  1780. X{
  1781. X    register struct monst *mtmp;
  1782. X    register struct obj *otmp;
  1783. X    register int typ;
  1784. X
  1785. X    bhitpos.x = u.ux;
  1786. X    bhitpos.y = u.uy;
  1787. X
  1788. X    if(sym) tmp_at(-1, sym);    /* open call */
  1789. X    while(range-- > 0) {
  1790. X        bhitpos.x += ddx;
  1791. X        bhitpos.y += ddy;
  1792. X        typ = levl[bhitpos.x][bhitpos.y].typ;
  1793. X        if(mtmp = m_at(bhitpos.x,bhitpos.y)){
  1794. X            if(sym) {
  1795. X                tmp_at(-1, -1);    /* close call */
  1796. X                return(mtmp);
  1797. X            }
  1798. X            (*fhitm)(mtmp, obj);
  1799. X            range -= 3;
  1800. X        }
  1801. X        /* modified by GAN to hit all objects */
  1802. X        if(fhito && o_at(bhitpos.x,bhitpos.y)){
  1803. X            int hitanything = 0;
  1804. X            for(otmp = fobj; otmp; otmp = otmp->nobj)
  1805. X                if(otmp->ox == bhitpos.x &&
  1806. X                   otmp->oy == bhitpos.y)
  1807. X                    hitanything += (*fhito)(otmp, obj);
  1808. X            if(hitanything)    range--;
  1809. X        }
  1810. X        if(!ZAP_POS(typ)) {
  1811. X            bhitpos.x -= ddx;
  1812. X            bhitpos.y -= ddy;
  1813. X            break;
  1814. X        }
  1815. X        if(sym) tmp_at(bhitpos.x, bhitpos.y);
  1816. X    }
  1817. X
  1818. X    /* leave last symbol unless in a pool */
  1819. X    if(sym)
  1820. X       tmp_at(-1, (levl[bhitpos.x][bhitpos.y].typ == POOL) ? -1 : 0);
  1821. X    return(0);
  1822. X}
  1823. X
  1824. Xstruct monst *
  1825. Xboomhit(dx,dy) {
  1826. X    register int i, ct;
  1827. X    register struct monst *mtmp;
  1828. X    char sym = ')';
  1829. X    extern schar xdir[], ydir[];
  1830. X
  1831. X    bhitpos.x = u.ux;
  1832. X    bhitpos.y = u.uy;
  1833. X
  1834. X    for(i=0; i<8; i++) if(xdir[i] == dx && ydir[i] == dy) break;
  1835. X    tmp_at(-1, sym);    /* open call */
  1836. X    for(ct=0; ct<10; ct++) {
  1837. X        if(i == 8) i = 0;
  1838. X        sym = ')' + '(' - sym;
  1839. X        tmp_at(-2, sym);    /* change let call */
  1840. X        dx = xdir[i];
  1841. X        dy = ydir[i];
  1842. X        bhitpos.x += dx;
  1843. X        bhitpos.y += dy;
  1844. X        if(mtmp = m_at(bhitpos.x, bhitpos.y)){
  1845. X            tmp_at(-1,-1);
  1846. X            return(mtmp);
  1847. X        }
  1848. X        if(!ZAP_POS(levl[bhitpos.x][bhitpos.y].typ)) {
  1849. X            bhitpos.x -= dx;
  1850. X            bhitpos.y -= dy;
  1851. X            break;
  1852. X        }
  1853. X        if(bhitpos.x == u.ux && bhitpos.y == u.uy) { /* ct == 9 */
  1854. X            if(rn2(20) >= 10+u.ulevel){    /* we hit ourselves */
  1855. X                (void) thitu(10, rnd(10), "boomerang");
  1856. X                break;
  1857. X            } else {    /* we catch it */
  1858. X                tmp_at(-1,-1);
  1859. X                pline("Skillfully, you catch the boomerang.");
  1860. X                return(&youmonst);
  1861. X            }
  1862. X        }
  1863. X        tmp_at(bhitpos.x, bhitpos.y);
  1864. X        if(ct % 5 != 0) i++;
  1865. X    }
  1866. X    tmp_at(-1, -1);    /* do not leave last symbol */
  1867. X    return(0);
  1868. X}
  1869. X
  1870. Xchar
  1871. Xdirlet(dx,dy) register dx,dy; {
  1872. X    return
  1873. X        (dx == dy) ? '\\' : (dx && dy) ? '/' : dx ? '-' : '|';
  1874. X}
  1875. X
  1876. X/* type == -1: monster spitting fire at you */
  1877. X/* type == -1,-2,-3: bolts sent out by wizard */
  1878. X/* called with dx = dy = 0 with vertical bolts */
  1879. Xbuzz(type,sx,sy,dx,dy)
  1880. Xregister int type;
  1881. Xregister xchar sx,sy;
  1882. Xregister int dx,dy;
  1883. X{
  1884. X    int abstype = (type == 10) ? 1 : abs(type);
  1885. X    register char *fltxt = (type == -1 || type == 10) ? "blaze of fire" : fl[abstype];
  1886. X    struct rm *lev;
  1887. X    xchar range;
  1888. X    struct monst *mon;
  1889. X
  1890. X    if(u.uswallow) {
  1891. X        register int tmp;
  1892. X
  1893. X        if(type < 0) return;
  1894. X        tmp = zhit(u.ustuck, type);
  1895. X        pline("The %s rips into %s%s",
  1896. X            fltxt, monnam(u.ustuck), exclam(tmp));
  1897. X        return;
  1898. X    }
  1899. X    if(type < 0) pru();
  1900. X    range = rn1(7,7);
  1901. X    Tmp_at(-1, dirlet(dx,dy));    /* open call */
  1902. X    while(range-- > 0) {
  1903. X        sx += dx;
  1904. X        sy += dy;
  1905. X        if((lev = &levl[sx][sy])->typ) Tmp_at(sx,sy);
  1906. X        else {
  1907. X            int bounce = 0;
  1908. X            if(cansee(sx-dx,sy-dy))
  1909. X                pline("The %s bounces!", fltxt);
  1910. X            if(ZAP_POS(levl[sx][sy-dy].typ))
  1911. X                bounce = 1;
  1912. X            if(ZAP_POS(levl[sx-dx][sy].typ)) {
  1913. X                if(!bounce || rn2(2)) bounce = 2;
  1914. X            }
  1915. X            switch(bounce){
  1916. X            case 0:
  1917. X                dx = -dx;
  1918. X                dy = -dy;
  1919. X                continue;
  1920. X            case 1:
  1921. X                dy = -dy;
  1922. X                sx -= dx;
  1923. X                break;
  1924. X            case 2:
  1925. X                dx = -dx;
  1926. X                sy -= dy;
  1927. X                break;
  1928. X            }
  1929. X            Tmp_at(-2,dirlet(dx,dy));
  1930. X            continue;
  1931. X        }
  1932. X        if(lev->typ == POOL && abstype == 1 /* fire */) {
  1933. X            range -= 3;
  1934. X            lev->typ = ROOM;
  1935. X            if(cansee(sx,sy)) {
  1936. X                mnewsym(sx,sy);
  1937. X                pline("The water evaporates.");
  1938. X            } else
  1939. X                pline("You hear a hissing sound.");
  1940. X        }
  1941. X        if(o_at(sx,sy) && abstype == 1)
  1942. X            if(burn_floor_scrolls(sx,sy) && cansee(sx,sy))  {
  1943. X                mnewsym(sx,sy);
  1944. X                pline("You see a puff of smoke.");
  1945. X            }
  1946. X        if((mon = m_at(sx,sy)) &&
  1947. X           (type != -1 || mon->data->mlet != 'D')) {
  1948. X            wakeup(mon);
  1949. X            if(rnd(20) < 18 + mon->data->ac) {
  1950. X                register int tmp = zhit(mon,abstype);
  1951. X                if(mon->mhp < 1) {
  1952. X                    if(type < 0) {
  1953. X                        if(cansee(mon->mx,mon->my))
  1954. X                          pline("%s is killed by the %s!",
  1955. X                        Monnam(mon), fltxt);
  1956. X                        mondied(mon);
  1957. X                    } else
  1958. X                        killed(mon);
  1959. X                } else
  1960. X                    hit(fltxt, mon, exclam(tmp));
  1961. X                range -= 2;
  1962. X            } else
  1963. X                miss(fltxt,mon);
  1964. X        } else if(sx == u.ux && sy == u.uy) {
  1965. X            nomul(0);
  1966. X            if(rnd(20) < 18+u.uac) {
  1967. X                register int dam = 0;
  1968. X                range -= 2;
  1969. X                pline("The %s hits you!",fltxt);
  1970. X                switch(abstype) {
  1971. X                case 0:
  1972. X                case 5:    dam = d(2,6);
  1973. X                    break;
  1974. X                case 1:
  1975. X                case 6:    if(Fire_resistance)
  1976. X                        pline("You don't feel hot!");
  1977. X                    else dam = d(6,6);
  1978. X                    if(!rn2(3)) {
  1979. X                        boil_potions();
  1980. X                        burn_scrolls();
  1981. X                    }
  1982. X                    break;
  1983. X                case 2:
  1984. X                case 7:    nomul(-rnd(25)); /* sleep ray */
  1985. X                    break;
  1986. X                case 3:
  1987. X                case 8:    if(Cold_resistance)
  1988. X                        pline("You don't feel cold!");
  1989. X                    else dam = d(6,6);
  1990. X                    break;
  1991. X                case 4:
  1992. X                case 9:    u.uhp = -1;
  1993. X                    break;
  1994. X                }
  1995. X                losehp(dam,fltxt);
  1996. X            } else pline("The %s whizzes by you!",fltxt);
  1997. X            stop_occupation();
  1998. X        }
  1999. X        if(!ZAP_POS(lev->typ)) {
  2000. X            int bounce = 0, rmn;
  2001. X            if(cansee(sx,sy)) pline("The %s bounces!",fltxt);
  2002. X            range--;
  2003. X            if(!dx || !dy || !rn2(20)){
  2004. X                dx = -dx;
  2005. X                dy = -dy;
  2006. X            } else {
  2007. X              if(ZAP_POS(rmn = levl[sx][sy-dy].typ) &&
  2008. X                (IS_ROOM(rmn) || ZAP_POS(levl[sx+dx][sy-dy].typ)))
  2009. X                bounce = 1;
  2010. X              if(ZAP_POS(rmn = levl[sx-dx][sy].typ) &&
  2011. X                (IS_ROOM(rmn) || ZAP_POS(levl[sx-dx][sy+dy].typ)))
  2012. X                if(!bounce || rn2(2))
  2013. X                    bounce = 2;
  2014. X
  2015. X              switch(bounce){
  2016. X              case 0:
  2017. X                dy = -dy;
  2018. X                dx = -dx;
  2019. X                break;
  2020. X              case 1:
  2021. X                dy = -dy;
  2022. X                break;
  2023. X              case 2:
  2024. X                dx = -dx;
  2025. X                break;
  2026. X              }
  2027. X              Tmp_at(-2, dirlet(dx,dy));
  2028. X            }
  2029. X        }
  2030. X    }
  2031. X    Tmp_at(-1,-1);
  2032. X}
  2033. X
  2034. Xzhit(mon,type)            /* returns damage to mon */
  2035. Xregister struct monst *mon;
  2036. Xregister type;
  2037. X{
  2038. X    register int tmp = 0;
  2039. X
  2040. X    switch(type) {
  2041. X    case 0:            /* magic missile */
  2042. X    case 5: tmp = d(2,6);
  2043. X        break;
  2044. X    case -1:        /* Dragon blazing fire */
  2045. X    case 1:            /* fire wand*/
  2046. X    case 6:            /* fire spell */
  2047. X    case 10:        /* Polymorphed human blazing fire */
  2048. X        if(index("Dg", mon->data->mlet)) break;
  2049. X        tmp = d(6,6);
  2050. X        if(index("YF", mon->data->mlet)) tmp += 7;
  2051. X        break;
  2052. X    case 2:            /* sleep*/
  2053. X    case 7: tmp = 0;
  2054. X        if(!resist(mon, (type == 2) ? '/' : '+', 0, NOTELL))
  2055. X            mon->mfroz = 1;
  2056. X        break;
  2057. X    case 3:            /* cold */
  2058. X    case 8:
  2059. X        if(index("YFgf", mon->data->mlet)) break;
  2060. X        tmp = d(6,6);
  2061. X        if(mon->data->mlet == 'D') tmp += 7;
  2062. X        break;
  2063. X    case 4:            /* death*/
  2064. X    case 9:
  2065. X        if(index(UNDEAD, mon->data->mlet)) break;
  2066. X        tmp = mon->mhp+1;
  2067. X        break;
  2068. X    }
  2069. X    if (resist(mon, (type < 5) ? '/' : '+', 0, NOTELL)) tmp /= 2;
  2070. X    mon->mhp -= tmp;
  2071. X    return(tmp);
  2072. X}
  2073. X
  2074. X#define    CORPSE_I_TO_C(otyp)    (char) ((otyp >= DEAD_ACID_BLOB)\
  2075. X             ?  'a' + (otyp - DEAD_ACID_BLOB)\
  2076. X             :    '@' + (otyp - DEAD_HUMAN))
  2077. Xrevive(obj)
  2078. Xregister struct obj *obj;
  2079. X{
  2080. X    register struct monst *mtmp;
  2081. X    register int let;
  2082. X
  2083. X    if(obj->olet == FOOD_SYM && obj->otyp > CORPSE) {
  2084. X#ifdef KAA
  2085. X        switch (obj->otyp) {
  2086. X            case DEAD_HUMAN: { let = 'Z'; break; }
  2087. X            case DEAD_GIANT: { let = '9'; break; }
  2088. X            case DEAD_DEMON: { let = '&'; break; }
  2089. X            default: let = CORPSE_I_TO_C(obj->otyp);
  2090. X        }
  2091. X        delobj(obj);
  2092. X/* Originally there was a bug which caused the object not to be erased
  2093. X   from the screen.  This happened because first the monster got created,
  2094. X   then the corpse removed.  Although delobj() called unpobj(), the object
  2095. X   didn't get erased from the screen because the monster was sitting on top
  2096. X   of it.  Solution: place the delobj() call before the mkmon() call. */
  2097. X        mtmp = mkmon_at(let, obj->ox, obj->oy);
  2098. X        if (mtmp && obj->otyp == DEAD_HUMAN) {
  2099. X            mtmp->mhp = mtmp->mhpmax = 100;
  2100. X            mtmp->mspeed = MFAST;
  2101. X        }
  2102. X#endif
  2103. X        /* do not (yet) revive shopkeepers */
  2104. X        /* Note: this might conceivably produce two monsters
  2105. X            at the same position - strange, but harmless */
  2106. X#ifndef KAA
  2107. X        delobj(obj);
  2108. X        mtmp = mkmon_at(CORPSE_I_TO_C(obj->otyp),obj->ox,obj->oy);
  2109. X#endif
  2110. X    }
  2111. X    return(!!mtmp);        /* TRUE if some monster created */
  2112. X}
  2113. X
  2114. Xrloco(obj)
  2115. Xregister struct obj *obj;
  2116. X{
  2117. X    register tx,ty,otx,oty;
  2118. X
  2119. X    otx = obj->ox;
  2120. X    oty = obj->oy;
  2121. X    do {
  2122. X        tx = rn1(COLNO-3,2);
  2123. X        ty = rn2(ROWNO);
  2124. X    } while(!goodpos(tx,ty));
  2125. X    obj->ox = tx;
  2126. X    obj->oy = ty;
  2127. X    if(cansee(otx,oty))
  2128. X        newsym(otx,oty);
  2129. X}
  2130. X
  2131. Xfracture_rock(obj)    /* fractured by pick-axe or wand of striking */
  2132. Xregister struct obj *obj;               /* no texts here! */
  2133. X{
  2134. X    /* unpobj(obj); */
  2135. X    obj->otyp = ROCK;
  2136. X    obj->quan = 7 + rn2(60);
  2137. X    obj->owt = weight(obj);
  2138. X    obj->olet = WEAPON_SYM;
  2139. X    if(cansee(obj->ox,obj->oy))
  2140. X        prl(obj->ox,obj->oy);
  2141. X}
  2142. X
  2143. Xboil_potions()
  2144. X{
  2145. X    register struct obj *obj, *obj2;
  2146. X    register int scrquan, i;
  2147. X    
  2148. X    for(obj = invent; obj; obj = obj2) {
  2149. X        obj2 = obj->nobj;
  2150. X        if(obj->olet == POTION_SYM) {
  2151. X            scrquan = obj->quan;
  2152. X            for(i = 1; i <= scrquan; i++) 
  2153. X                if(!rn2(3)) {
  2154. X                    pline("%s %s boils and explodes!",
  2155. X                    (obj->quan != 1) ? "One of your" : "Your",
  2156. X                    xname(obj));
  2157. X                    potionbreathe(obj);
  2158. X                    useup(obj);
  2159. X                    losehp(rn2(4),"boiling potion");
  2160. X                }
  2161. X        }
  2162. X    }
  2163. X}
  2164. X                
  2165. Xburn_scrolls()
  2166. X{
  2167. X    register struct obj *obj, *obj2;
  2168. X    register int cnt = 0;
  2169. X    register int scrquan, i;
  2170. X
  2171. X    for(obj = invent; obj; obj = obj2) {
  2172. X        obj2 = obj->nobj;
  2173. X        if(obj->olet == SCROLL_SYM) {
  2174. X            scrquan = obj->quan;
  2175. X            for(i = 1; i <= scrquan ; i++)
  2176. X                if(!rn2(3))  {
  2177. X                    cnt++;
  2178. X                    useup(obj);
  2179. X                }
  2180. X        }
  2181. X    }
  2182. X
  2183. X    /* "Killed by a burning scrolls" doesn't make too much sense.  KAA*/
  2184. X    if (cnt) {
  2185. X        pline("%s of your scrolls catch%s fire!",
  2186. X        cnt==1 ? "One" : "Some", cnt==1 ? "es" : "");
  2187. X        if(Fire_resistance)
  2188. X            pline("You aren't hurt!");
  2189. X        else
  2190. X            losehp(cnt,"burning scroll");
  2191. X    }
  2192. X}
  2193. X
  2194. Xresist(mtmp, olet, damage, tell)
  2195. Xregister struct monst    *mtmp;
  2196. Xregister char    olet;
  2197. Xregister int    damage, tell;
  2198. X{
  2199. Xregister int    resisted = 0;
  2200. X#ifdef HARD
  2201. Xregister int    level;
  2202. X
  2203. X    switch(olet)  {
  2204. X
  2205. X        case '/':    level = 8;
  2206. X            break;
  2207. X
  2208. X        case '?':    level = 6;
  2209. X            break;
  2210. X
  2211. X        case '!':    level = 5;
  2212. X            break;
  2213. X
  2214. X        default:    level = u.ulevel;
  2215. X            break;
  2216. X    }
  2217. X
  2218. X    resisted = (rn2(100) - mtmp->data->mlevel + level) < mtmp->data->mr;
  2219. X    if(resisted) {
  2220. X
  2221. X        if(tell) pline("The %s resists!", mtmp->data->mname);
  2222. X        mtmp->mhp -= damage/2;
  2223. X    } else
  2224. X#endif
  2225. X        mtmp->mhp -= damage;
  2226. X
  2227. X    if(mtmp->mhp < 1) killed(mtmp);
  2228. X    return(resisted);
  2229. X}
  2230. X
  2231. X/*
  2232. X * burn scrolls on floor at position x,y
  2233. X * return the number of scrolls burned
  2234. X */
  2235. Xint
  2236. Xburn_floor_scrolls(x,y)
  2237. X{
  2238. X    register struct obj *obj, *obj2;
  2239. X    register int scrquan, i;
  2240. X    register int cnt = 0;
  2241. X
  2242. X    for(obj = fobj; obj; obj = obj2) {
  2243. X        obj2 = obj->nobj;
  2244. X        /* Bug fix - KAA */
  2245. X        if(obj->ox == x && obj->oy == y && obj->olet == SCROLL_SYM) {
  2246. X            scrquan = obj->quan;
  2247. X            for(i = 1; i <= scrquan ; i++)
  2248. X                if(!rn2(3))  {
  2249. X                    cnt++;
  2250. X                    useupf(obj);
  2251. X                }
  2252. X        }
  2253. X    }
  2254. X    return(cnt);
  2255. X}
  2256. X
  2257. Xmakewish()    /* Separated as there are now 3 places you can wish at. */
  2258. X{
  2259. X    char buf[BUFSZ];
  2260. X    register struct obj *otmp;
  2261. X    extern struct obj *readobjnam(), *addinv();
  2262. X    int wishquan, mergquan;
  2263. X
  2264. X    pline("You may wish for an object. What do you want? ");
  2265. X    getlin(buf);
  2266. X    if(buf[0] == '\033') buf[0] = 0;
  2267. X    otmp = readobjnam(buf);
  2268. X#ifdef KAA
  2269. X/* Wishing for gold has been implemented in readobjnam() and returns 0
  2270. X   if successful. */
  2271. X    if (otmp) { 
  2272. X#endif
  2273. X        wishquan = otmp->quan;
  2274. X        otmp = addinv(otmp);
  2275. X        /* indented lines added below so quantity shows
  2276. X         *  right.     GAN - 11/13/86
  2277. X         */
  2278. X          mergquan = otmp->quan;
  2279. X          otmp->quan = wishquan; /* to fool prinv() */
  2280. X        prinv(otmp);
  2281. X          otmp->quan = mergquan;
  2282. X#ifdef KAA
  2283. X    }
  2284. X#endif
  2285. X}
  2286. END_OF_zap.c
  2287. if test 23766 -ne `wc -c <zap.c`; then
  2288.     echo shar: \"zap.c\" unpacked with wrong size!
  2289. fi
  2290. # end of overwriting check
  2291. fi
  2292. echo shar: End of archive 3 \(of 16\).
  2293. cp /dev/null ark3isdone
  2294. MISSING=""
  2295. for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ; do
  2296.     if test ! -f ark${I}isdone ; then
  2297.     MISSING="${MISSING} ${I}"
  2298.     fi
  2299. done
  2300. if test "${MISSING}" = "" ; then
  2301.     echo You have unpacked all 16 archives.
  2302.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2303. else
  2304.     echo You still need to unpack the following archives:
  2305.     echo "        " ${MISSING}
  2306. fi
  2307. ##  End of shell archive.
  2308. exit 0
  2309.